home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / string.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  9KB  |  296 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. whitespace = ' \t\n\r\x0b\x0c'
  5. lowercase = 'abcdefghijklmnopqrstuvwxyz'
  6. uppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  7. letters = lowercase + uppercase
  8. ascii_lowercase = lowercase
  9. ascii_uppercase = uppercase
  10. ascii_letters = ascii_lowercase + ascii_uppercase
  11. digits = '0123456789'
  12. hexdigits = digits + 'abcdef' + 'ABCDEF'
  13. octdigits = '01234567'
  14. punctuation = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~'
  15. printable = digits + letters + punctuation + whitespace
  16. l = map(chr, xrange(256))
  17. _idmap = str('').join(l)
  18. del l
  19.  
  20. def capwords(s, sep = None):
  21.     if not sep:
  22.         pass
  23.     return []([ x.capitalize() for x in s.split(sep) ])
  24.  
  25. _idmapL = None
  26.  
  27. def maketrans(fromstr, tostr):
  28.     global _idmapL
  29.     if len(fromstr) != len(tostr):
  30.         raise ValueError, 'maketrans arguments must have same length'
  31.     
  32.     if not _idmapL:
  33.         _idmapL = map(None, _idmap)
  34.     
  35.     L = _idmapL[:]
  36.     fromstr = map(ord, fromstr)
  37.     for i in range(len(fromstr)):
  38.         L[fromstr[i]] = tostr[i]
  39.     
  40.     return ''.join(L)
  41.  
  42. import re as _re
  43.  
  44. class _multimap:
  45.     
  46.     def __init__(self, primary, secondary):
  47.         self._primary = primary
  48.         self._secondary = secondary
  49.  
  50.     
  51.     def __getitem__(self, key):
  52.         
  53.         try:
  54.             return self._primary[key]
  55.         except KeyError:
  56.             return self._secondary[key]
  57.  
  58.  
  59.  
  60.  
  61. class _TemplateMetaclass(type):
  62.     pattern = '\n    %(delim)s(?:\n      (?P<escaped>%(delim)s) |   # Escape sequence of two delimiters\n      (?P<named>%(id)s)      |   # delimiter and a Python identifier\n      {(?P<braced>%(id)s)}   |   # delimiter and a braced identifier\n      (?P<invalid>)              # Other ill-formed delimiter exprs\n    )\n    '
  63.     
  64.     def __init__(cls, name, bases, dct):
  65.         super(_TemplateMetaclass, cls).__init__(name, bases, dct)
  66.         if 'pattern' in dct:
  67.             pattern = cls.pattern
  68.         else:
  69.             pattern = _TemplateMetaclass.pattern % {
  70.                 'delim': _re.escape(cls.delimiter),
  71.                 'id': cls.idpattern }
  72.         cls.pattern = _re.compile(pattern, _re.IGNORECASE | _re.VERBOSE)
  73.  
  74.  
  75.  
  76. class Template:
  77.     __metaclass__ = _TemplateMetaclass
  78.     delimiter = '$'
  79.     idpattern = '[_a-z][_a-z0-9]*'
  80.     
  81.     def __init__(self, template):
  82.         self.template = template
  83.  
  84.     
  85.     def _invalid(self, mo):
  86.         i = mo.start('invalid')
  87.         lines = self.template[:i].splitlines(True)
  88.         if not lines:
  89.             colno = 1
  90.             lineno = 1
  91.         else:
  92.             colno = i - len(''.join(lines[:-1]))
  93.             lineno = len(lines)
  94.         raise ValueError('Invalid placeholder in string: line %d, col %d' % (lineno, colno))
  95.  
  96.     
  97.     def substitute(self, *args, **kws):
  98.         if len(args) > 1:
  99.             raise TypeError('Too many positional arguments')
  100.         
  101.         if not args:
  102.             mapping = kws
  103.         elif kws:
  104.             mapping = _multimap(kws, args[0])
  105.         else:
  106.             mapping = args[0]
  107.         
  108.         def convert(mo):
  109.             if not mo.group('named'):
  110.                 pass
  111.             named = mo.group('braced')
  112.             if named is not None:
  113.                 val = mapping[named]
  114.                 return '%s' % (val,)
  115.             
  116.             if mo.group('escaped') is not None:
  117.                 return self.delimiter
  118.             
  119.             if mo.group('invalid') is not None:
  120.                 self._invalid(mo)
  121.             
  122.             raise ValueError('Unrecognized named group in pattern', self.pattern)
  123.  
  124.         return self.pattern.sub(convert, self.template)
  125.  
  126.     
  127.     def safe_substitute(self, *args, **kws):
  128.         if len(args) > 1:
  129.             raise TypeError('Too many positional arguments')
  130.         
  131.         if not args:
  132.             mapping = kws
  133.         elif kws:
  134.             mapping = _multimap(kws, args[0])
  135.         else:
  136.             mapping = args[0]
  137.         
  138.         def convert(mo):
  139.             named = mo.group('named')
  140.             if named is not None:
  141.                 
  142.                 try:
  143.                     return '%s' % (mapping[named],)
  144.                 except KeyError:
  145.                     return self.delimiter + named
  146.                 except:
  147.                     None<EXCEPTION MATCH>KeyError
  148.                 
  149.  
  150.             None<EXCEPTION MATCH>KeyError
  151.             braced = mo.group('braced')
  152.             if braced is not None:
  153.                 
  154.                 try:
  155.                     return '%s' % (mapping[braced],)
  156.                 except KeyError:
  157.                     return self.delimiter + '{' + braced + '}'
  158.                 except:
  159.                     None<EXCEPTION MATCH>KeyError
  160.                 
  161.  
  162.             None<EXCEPTION MATCH>KeyError
  163.             if mo.group('escaped') is not None:
  164.                 return self.delimiter
  165.             
  166.             if mo.group('invalid') is not None:
  167.                 return self.delimiter
  168.             
  169.             raise ValueError('Unrecognized named group in pattern', self.pattern)
  170.  
  171.         return self.pattern.sub(convert, self.template)
  172.  
  173.  
  174. index_error = ValueError
  175. atoi_error = ValueError
  176. atof_error = ValueError
  177. atol_error = ValueError
  178.  
  179. def lower(s):
  180.     return s.lower()
  181.  
  182.  
  183. def upper(s):
  184.     return s.upper()
  185.  
  186.  
  187. def swapcase(s):
  188.     return s.swapcase()
  189.  
  190.  
  191. def strip(s, chars = None):
  192.     return s.strip(chars)
  193.  
  194.  
  195. def lstrip(s, chars = None):
  196.     return s.lstrip(chars)
  197.  
  198.  
  199. def rstrip(s, chars = None):
  200.     return s.rstrip(chars)
  201.  
  202.  
  203. def split(s, sep = None, maxsplit = -1):
  204.     return s.split(sep, maxsplit)
  205.  
  206. splitfields = split
  207.  
  208. def rsplit(s, sep = None, maxsplit = -1):
  209.     return s.rsplit(sep, maxsplit)
  210.  
  211.  
  212. def join(words, sep = ' '):
  213.     return sep.join(words)
  214.  
  215. joinfields = join
  216.  
  217. def index(s, *args):
  218.     return s.index(*args)
  219.  
  220.  
  221. def rindex(s, *args):
  222.     return s.rindex(*args)
  223.  
  224.  
  225. def count(s, *args):
  226.     return s.count(*args)
  227.  
  228.  
  229. def find(s, *args):
  230.     return s.find(*args)
  231.  
  232.  
  233. def rfind(s, *args):
  234.     return s.rfind(*args)
  235.  
  236. _float = float
  237. _int = int
  238. _long = long
  239.  
  240. def atof(s):
  241.     return _float(s)
  242.  
  243.  
  244. def atoi(s, base = 10):
  245.     return _int(s, base)
  246.  
  247.  
  248. def atol(s, base = 10):
  249.     return _long(s, base)
  250.  
  251.  
  252. def ljust(s, width, *args):
  253.     return s.ljust(width, *args)
  254.  
  255.  
  256. def rjust(s, width, *args):
  257.     return s.rjust(width, *args)
  258.  
  259.  
  260. def center(s, width, *args):
  261.     return s.center(width, *args)
  262.  
  263.  
  264. def zfill(x, width):
  265.     if not isinstance(x, basestring):
  266.         x = repr(x)
  267.     
  268.     return x.zfill(width)
  269.  
  270.  
  271. def expandtabs(s, tabsize = 8):
  272.     return s.expandtabs(tabsize)
  273.  
  274.  
  275. def translate(s, table, deletions = ''):
  276.     if deletions:
  277.         return s.translate(table, deletions)
  278.     else:
  279.         return s.translate(table + s[:0])
  280.  
  281.  
  282. def capitalize(s):
  283.     return s.capitalize()
  284.  
  285.  
  286. def replace(s, old, new, maxsplit = -1):
  287.     return s.replace(old, new, maxsplit)
  288.  
  289.  
  290. try:
  291.     from strop import maketrans, lowercase, uppercase, whitespace
  292.     letters = lowercase + uppercase
  293. except ImportError:
  294.     pass
  295.  
  296.